package fiveGame.Util;

import java.util.Arrays;
import java.util.Scanner;

/** 

* @author Tiangle 

* @version 3.0

* @see 控制台输入int、String、double；数组连接、数组扩容、数组是否为空、数组增删改等

*/
public class TiangleUtil {
	Scanner input = new Scanner(System.in);
	//控制台输入int类型
	public int getInt() {
		boolean flag = true;
		do{
			input = new Scanner(System.in);
			if(input.hasNextInt()) {
				return input.nextInt();
			}else {
				System.out.println("不是数字请重新输入");
			}
		}while(flag) ;
		return 0;
	}
	//控制台输入int类型，参数分别为int的下界和上届
	public int getInt(int min,int max) {
		boolean flag = true;
		do{
			input = new Scanner(System.in);
			
			if(input.hasNextInt()) {
				int a = input.nextInt();
				if(a>=min&&a<=max) {
					return a;
				}else {
					System.out.println("数字超过范围");
				}
				
			}else {
				System.out.println("不是数字请重新输入");
			}
		}while(flag) ;
		return 0;
	}
	//控制台输入double的值
	public double getDouble() {
		boolean flag = true;
		do{
			input = new Scanner(System.in);
			if(input.hasNextDouble()) {
				return input.nextDouble();
			}else {
				System.out.println("不是数字请重新输入");
			}
		}while(flag) ;
		return 0;
	}
	//控制台输入double，参数分别为double的下界和上届
	public double getDouble(double min,double max) {
		boolean flag = true;
		do{
			input = new Scanner(System.in);
			if(input.hasNextDouble()) {
				double a = input.nextInt();
				if(a>=min&&a<=max) {
					return a;
				}else {
					System.out.println("数字超过范围");
				}
			}else {
				System.out.println("不是数字请重新输入");
			}
		}while(flag) ;
		return 0;
	}
	
	//控制台输入字符
	public char getChar() {
		boolean flag = true;
		do{
			input = new Scanner(System.in);
			String s = input.next();
			if(s.length() == 1) {
				return s.charAt(0);
			}else {
				System.out.println("不是字符请重新输入");
			}
		}while(flag) ;
		return 0;
	}
	//控制台输入字符，判断规则又字符串作为参数
	public char getChar(String a) {
		boolean flag = true;
		do{
			input = new Scanner(System.in);
			String s = input.next();
			if(s.length() == 1) {
				for(int i = 0;i<a.length();i++) {
					if(s.charAt(0) == a.charAt(i)) {
						return s.charAt(0);
					}
				}
				System.out.println("不在输入规则内，请重新输入");
				
			}else {
				System.out.println("不是字符请重新输入");
			}
		}while(flag) ;
		return 0;
	}
	//平平无奇的返回字符串
	public String getString() {
		return input.next();
	}
	//输入字符串必须是规则范围内的，规则为String数组内的字符串
	public String getString(String[] x) {
		while(true) {
			String s = input.next();
			for(String a:x) {
				if(a.equals(s)) {
					return s;
				}
			}
			System.out.println("输入内容不符合规则");
		}
		
	
	}
	//控制台输入规则的两种字符，一种返回true一种返回false
	public boolean getBoolean(String y,String n) {
		
		while(true) {
			String s = input.next();
			if(s.equals(y)) {
				return true;
			}else if(s.equals(n)){
				return false;
			}else {
				System.out.println("不符合输入规则");
			}
		}
		
	}
	//数组扩容n个长度(数组不能为null)
	public <E> E[] addLength(E[] a,int n) {
		if(a == null) {
			return null;
		}
		if(a[a.length-1]!=null) {
			a = Arrays.copyOf(a, a.length+n);
		}
		
		
		return a;	
	}
	//两个数组连接
	public <T> T[] concat(T[] first, T[] second) {
		  T[] result = Arrays.copyOf(first, first.length + second.length);
		  System.arraycopy(second, 0, result, first.length, second.length);
		  return result;
	}
	//判断数组是否为空
	public <E> boolean isNull(E[] a) {
		if(a==null) {
			return true;
		}else {
			return false;
		}
	}
	//是否为满
	public <E> boolean isFull(E[] s) {
		if(this.isNull(s))
			return false;
		if(s[s.length-1]!=null) {
			return true;
		}else {
			return false;
		}
	}
	//添加元素到数组（从0开始遍历一直到null位置添加,返回新数组）
	public <E> E[] addOne(E[] s,E a) {
		if(this.isNull(s)) {
			return s;
		}
		if(this.isFull(s)) {
			s = this.addLength(s, 1);
		}
		for(int i = 0;i<s.length;i++) {
			if(s[i]==null) {
				s[i] = a;
				return s;
			}
		}
		return s;
	}
	//更改数组某个元素，成true不成false
	public <E> boolean editOne(E[] s,E old,E newo) {
		if(this.isNull(s)) {
			return false;
		}
		for(int i = 0;i < s.length;i++) {
			if(s[i].toString().equals(old.toString())) {
				s[i] = newo;
				return true;
			}
		}
		return false;
	}
	//删除数组某个元素，成不成都返回数组（如多个则删第一个）
	public <E> E[] deleteOne(E[] s,E old) {
		if(this.isNull(s)) {
			return s;
		}
		for(int i = 0;i < s.length;i++) {
			if(s[i].toString().equals(old.toString())) {
				for(int j = i;j < s.length-1;j++) {
					s[j] = s[j+1];
				}
				s = Arrays.copyOf(s, s.length-1);
				return s;
			}
		}
		return s;
	}
	//已知下标删它
	public <E> E[] deleteOne(E[] s,int index) {
		if(this.isNull(s)) {
			return s;
		}
		
		for(int j = index;j < s.length-1;j++) {
			s[j] = s[j+1];
		}
		s = Arrays.copyOf(s, s.length-1);
		
		return s;
	}
	
}
